// ======================================
// 包声明部分
// ======================================
// 定义包名,指定代码所在的包路径，这是Android应用程序的唯一标识符
package com.example.myapplication8

// ======================================
// 导入声明部分 - 每个import都是必要的功能组件
// ======================================
// 用于处理Intent，实现界面跳转和组件间通信
import android.content.Intent
// 用于处理URI，主要用于构建权限请求等场景的地址
import android.net.Uri
// 用于获取Android系统版本信息，处理版本兼容性
import android.os.Build
// 用于在Activity间传递数据的包装器
import android.os.Bundle
// 用于访问系统设置的工具类
import android.provider.Settings
// 用于创建选项菜单
import android.view.Menu
// 用于处理菜单项
import android.view.MenuItem
// 用于显示简短提示信息
import android.widget.Toast
// 用于操作圆形按钮控件
import android.widget.ImageButton
// Material Design风格的提示条，提供更丰富的交互
import com.google.android.material.snackbar.Snackbar
// Material Design风格的导航视图组件
import com.google.android.material.navigation.NavigationView
// 用于获取导航控制器的工具类
import androidx.navigation.findNavController
// 导航宿主Fragment，用于管理导航
import androidx.navigation.fragment.NavHostFragment
// 应用栏配置类，用于设置顶部导航栏
import androidx.navigation.ui.AppBarConfiguration
// 处理向上导航的工具类
import androidx.navigation.ui.navigateUp
// 设置ActionBar与导航控制器关联的工具类
import androidx.navigation.ui.setupActionBarWithNavController
// 设置导航控制器的工具类
import androidx.navigation.ui.setupWithNavController
// 提供向后兼容性的Activity基类
import androidx.appcompat.app.AppCompatActivity
// 视图绑定类，用于安全地访问视图
import com.example.myapplication8.databinding.ActivityMainBinding
// 悬浮窗服务类
import com.example.myapplication8.service.FloatingWindowService
// 无障碍服务类
import com.example.myapplication8.service.MyAccessibilityService
// 日志工具类
import android.util.Log
// 上下文类，用于访问应用程序环境
import android.content.Context
// 无障碍服务管理器
import android.view.accessibility.AccessibilityManager
// 无障碍服务信息类
import android.accessibilityservice.AccessibilityServiceInfo
// 组件名称类
import android.content.ComponentName
// 处理Activity结果的新API
import androidx.activity.result.contract.ActivityResultContracts
// 抽屉布局的开关控制器
import androidx.appcompat.app.ActionBarDrawerToggle
// 处理视图引力的工具类
import androidx.core.view.GravityCompat
// 抽屉布局组件
import androidx.drawerlayout.widget.DrawerLayout
// 对话框组件
import android.app.AlertDialog
// 文件操作类
import java.io.File

// ======================================
// MainActivity类定义
// ======================================
/**
 * MainActivity是应用程序的主要入口点
 * 继承自AppCompatActivity以提供向后兼容性
 * 实现NavigationView.OnNavigationItemSelectedListener接口以处理导航项的选择
 */
class MainActivity : AppCompatActivity(), NavigationView.OnNavigationItemSelectedListener {

    // ======================================
    // 属性声明部分
    // ======================================
    
    /**
     * appBarConfiguration用于配置顶部应用栏
     * lateinit表示延迟初始化，在使用前必须初始化
     */
    private lateinit var appBarConfiguration: AppBarConfiguration
    
    /**
     * binding用于视图绑定，提供类型安全的视图访问方式
     * lateinit表示延迟初始化
     */
    private lateinit var binding: ActivityMainBinding
    
    /**
     * 悬浮窗权限请求的识别码
     */
    private val OVERLAY_PERMISSION_REQUEST_CODE = 1
    
    /**
     * 跟踪悬浮窗是否已启动的标志
     */
    private var isFloatingWindowStarted = false
    
    /**
     * 圆形按钮的引用
     * lateinit表示延迟初始化
     */
    private lateinit var circleButton: ImageButton
    
    /**
     * 抽屉布局的引用
     * 可空类型，因为可能不存在
     */
    private var drawerLayout: DrawerLayout? = null
    
    /**
     * 抽屉布局的开关控制器
     * 可空类型，因为可能不存在
     */
    private var toggle: ActionBarDrawerToggle? = null
    
    /**
     * 跟踪无障碍服务对话框是否显示的标志
     */
    private var isShowingAccessibilityDialog = false

    /**
     * 注册权限请求回调
     * 使用新的Activity Result API处理悬浮窗权限请求的结果
     * 当用户从系统设置返回后会触发此回调
     */
    private val overlayPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { 
        // 检查Android 6.0及以上版本的悬浮窗权限
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && Settings.canDrawOverlays(this)) {
            // 权限获取成功，启动悬浮窗
            startFloatingWindow()
            // 更新按钮状态为已启动
            updateCircleButtonState(true)
        } else {
            // 权限获取失败，显示提示
            Toast.makeText(this, "权限被拒绝", Toast.LENGTH_SHORT).show()
            // 更新按钮状态为未启动
            updateCircleButtonState(false)
        }
    }

    /**
     * Activity的创建生命周期方法
     * 在Activity首次创建时调用
     * 负责初始化Activity的基本组件
     * @param savedInstanceState 保存的实例状态Bundle，可能为null
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        try {
            // 调用父类的onCreate方法
            super.onCreate(savedInstanceState)
            
            try {
                // 初始化视图绑定
                binding = ActivityMainBinding.inflate(layoutInflater)
                // 设置Activity的内容视图
                setContentView(binding.root)
            } catch (e: Exception) {
                // 记录视图绑定错误
                Log.e("MainActivity", "Error inflating layout: ${e.message}")
                // 如果视图绑定失败，使用传统方式设置布局
                setContentView(R.layout.activity_main)
            }

            try {
                // 设置工具栏为ActionBar
                setSupportActionBar(binding.appBarMain.toolbar)
            } catch (e: Exception) {
                // 记录工具栏设置错误
                Log.e("MainActivity", "Error setting up toolbar: ${e.message}")
            }

            // 初始化抽屉布局和导航组件
            setupNavigationDrawer()

            try {
                // 初始化圆形按钮
                setupCircleButton()
            } catch (e: Exception) {
                // 记录按钮设置错误
                Log.e("MainActivity", "Error setting up circle button: ${e.message}")
            }

            try {
                // 检查并请求必要的权限
                checkAndRequestPermissions()
            } catch (e: Exception) {
                // 记录权限检查错误
                Log.e("MainActivity", "Error checking permissions: ${e.message}")
            }
            
        } catch (e: Exception) {
            // 记录onCreate方法的致命错误
            Log.e("MainActivity", "Fatal error in onCreate: ${e.message}")
            e.printStackTrace()
            try {
                // 显示错误提示
                Toast.makeText(this, "应用启动失败，请重试", Toast.LENGTH_LONG).show()
            } catch (e: Exception) {
                // 记录Toast显示错误
                Log.e("MainActivity", "Could not show error toast: ${e.message}")
            }
        }
    }

    /**
     * 设置抽屉布局和导航
     * 初始化并配置导航抽屉、导航视图和导航控制器
     * 处理导航相关的所有设置和监听器
     */
    private fun setupNavigationDrawer() {
        try {
            // 从视图绑定中获取DrawerLayout实例
            drawerLayout = binding.drawerLayout
            // 获取导航视图实例
            val navView = binding.navView

            // 检查必要组件是否成功获取
            if (drawerLayout == null || navView == null) {
                Log.e("MainActivity", "DrawerLayout or NavigationView is null")
                return
            }

            // 创建抽屉开关，用于控制抽屉的打开和关闭
            toggle = ActionBarDrawerToggle(
                this,                   // Activity上下文
                drawerLayout!!,         // DrawerLayout实例
                binding.appBarMain.toolbar,  // 工具栏
                R.string.navigation_drawer_open,   // 抽屉打开描述
                R.string.navigation_drawer_close   // 抽屉关闭描述
            )

            // 将抽屉监听器添加到DrawerLayout
            drawerLayout?.addDrawerListener(toggle!!)
            // 同步抽屉状态
            toggle?.syncState()

            try {
                // 获取导航宿主Fragment
                val navHostFragment = supportFragmentManager
                    .findFragmentById(R.id.nav_host_fragment_content_main) as? NavHostFragment
                    ?: throw Exception("NavHostFragment not found")
                    
                // 获取导航控制器
                val navController = navHostFragment.navController

                // 配置应用栏，设置顶级导航目标
                appBarConfiguration = AppBarConfiguration(
                    setOf(  // 设置顶级导航目标
                        R.id.nav_transform,
                        R.id.nav_reflow,
                        R.id.nav_slideshow,
                        R.id.nav_settings
                    ),
                    drawerLayout  // 关联抽屉布局
                )

                // 设置ActionBar与导航控制器的联动
                setupActionBarWithNavController(navController, appBarConfiguration)
                // 设置导航视图与导航控制器的联动
                navView.setupWithNavController(navController)
                // 设置底部导航栏与导航控制器的联动（如果存在）
                binding.appBarMain.contentMain.bottomNavView?.setupWithNavController(navController)

                // 设置导航项选择监听器
                navView.setNavigationItemSelectedListener(this)
            } catch (e: Exception) {
                // 记录导航控制器设置错误
                Log.e("MainActivity", "Error setting up navigation controller: ${e.message}")
                e.printStackTrace()
                Toast.makeText(this, "导航初始化失败", Toast.LENGTH_SHORT).show()
            }
        } catch (e: Exception) {
            // 记录整体导航抽屉设置错误
            Log.e("MainActivity", "Error setting up navigation drawer: ${e.message}")
            e.printStackTrace()
            Toast.makeText(this, "侧边栏初始化失败", Toast.LENGTH_SHORT).show()
        }
    }

    /**
     * 检查并请求必要的权限
     * 包括悬浮窗权限和无障碍服务权限
     * 如果权限未授予，会显示对话框引导用户授权
     */
    private fun checkAndRequestPermissions() {
        try {
            // 检查Android 6.0及以上版本的悬浮窗权限
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.canDrawOverlays(this)) {
                // 显示Snackbar提示用户需要悬浮窗权限
                Snackbar.make(
                    binding.root,
                    "需要悬浮窗权限才能显示悬浮窗",
                    Snackbar.LENGTH_LONG
                ).setAction("去设置") {
                    try {
                        // 创建打开悬浮窗权限设置的Intent
                        val intent = Intent(
                            Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                            Uri.parse("package:$packageName")
                        )
                        // 启动权限设置界面
                        overlayPermissionLauncher.launch(intent)
                    } catch (e: Exception) {
                        // 记录打开设置失败的错误
                        Log.e("MainActivity", "Error launching overlay permission: ${e.message}")
                        Toast.makeText(this, "打开设置失败，请手动开启权限", Toast.LENGTH_SHORT).show()
                    }
                }.show()
            }

            // 检查无障碍服务权限
            if (!isShowingAccessibilityDialog) {
                // 延迟检查，确保UI已完全加载
                binding.root.post {
                    try {
                        // 检查无障碍服务是否已启用
                        if (!isAccessibilityServiceEnabled()) {
                            // 设置对话框显示标志
                            isShowingAccessibilityDialog = true
                            // 创建并显示提示对话框
                            AlertDialog.Builder(this)
                                .setTitle("无障碍服务未开启")
                                .setMessage("应用需要无障碍服务权限才能正常运行，是否前往开启？")
                                .setPositiveButton("去开启") { _, _ ->
                                    try {
                                        // 创建打开无障碍服务设置的Intent
                                        val intent = Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS)
                                        startActivity(intent)
                                    } catch (e: Exception) {
                                        // 记录打开设置失败的错误
                                        Log.e("MainActivity", "Error opening accessibility settings: ${e.message}")
                                        Toast.makeText(this, "打开设置失败，请手动开启无障碍服务", Toast.LENGTH_SHORT).show()
                                    }
                                    // 重置对话框显示标志
                                    isShowingAccessibilityDialog = false
                                }
                                .setNegativeButton("暂不开启") { _, _ ->
                                    // 用户选择不开启时的处理
                                    Toast.makeText(this, "部分功能可能无法正常使用", Toast.LENGTH_LONG).show()
                                    // 重置对话框显示标志
                                    isShowingAccessibilityDialog = false
                                }
                                .setOnCancelListener {
                                    // 对话框取消时重置显示标志
                                    isShowingAccessibilityDialog = false
                                }
                                .setCancelable(false) // 禁止点击外部取消对话框
                                .show()
                        }
                    } catch (e: Exception) {
                        // 记录检查无障碍服务状态失败的错误
                        Log.e("MainActivity", "Error checking accessibility service: ${e.message}")
                        Toast.makeText(this, "检查无障碍服务状态失败", Toast.LENGTH_SHORT).show()
                        // 重置对话框显示标志
                        isShowingAccessibilityDialog = false
                    }
                }
            }
        } catch (e: Exception) {
            // 记录权限检查过程中的错误
            Log.e("MainActivity", "Error in checkAndRequestPermissions: ${e.message}")
            Toast.makeText(this, "权限检查失败", Toast.LENGTH_SHORT).show()
            // 重置对话框显示标志
            isShowingAccessibilityDialog = false
        }
    }

    /**
     * 初始化圆形按钮
     * 设置按钮的引用、点击事件和初始状态
     * 包含多重异常处理和降级策略
     */
    private fun setupCircleButton() {
        try {
            // 通过多种方式尝试获取按钮引用，确保能找到按钮
            circleButton = try {
                // 方式1：通过视图绑定的层级结构查找
                binding.appBarMain.contentMain.circleButtonContainer?.root?.findViewById(R.id.circle_button)
                    // 方式2：通过视图绑定的根视图查找
                    ?: binding.appBarMain.contentMain.root.findViewById(R.id.circle_button)
                    // 方式3：通过Activity的findViewById直接查找
                    ?: findViewById(R.id.circle_button)
            } catch (e: Exception) {
                // 记录通过绑定查找按钮失败的错误
                Log.e("MainActivity", "Error finding button through binding: ${e.message}")
                // 最后尝试：直接通过findViewById查找
                findViewById(R.id.circle_button) ?: throw IllegalStateException("Could not find circle button")
            }
            
            // 记录按钮引用获取成功
            Log.d("MainActivity", "Button reference: $circleButton")

            // 设置按钮的点击事件监听器
            circleButton.setOnClickListener {
                // 记录按钮点击事件
                Log.d("MainActivity", "Button clicked")
                
                // 检查悬浮窗是否已启动
                if (!isFloatingWindowStarted) {
                    // 检查Android 6.0及以上版本的悬浮窗权限
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.canDrawOverlays(this)) {
                        // 记录需要请求悬浮窗权限
                        Log.d("MainActivity", "Requesting overlay permission")
                        // 显示Snackbar提示用户需要权限
                        Snackbar.make(
                            binding.root,
                            "需要悬浮窗权限才能显示悬浮窗",
                            Snackbar.LENGTH_LONG
                        ).setAction("去设置") {
                            try {
                                // 创建打开悬浮窗权限设置的Intent
                                val intent = Intent(
                                    Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                                    Uri.parse("package:$packageName")
                                )
                                // 启动权限设置界面
                                overlayPermissionLauncher.launch(intent)
                            } catch (e: Exception) {
                                // 记录打开设置失败的错误
                                Log.e("MainActivity", "Error launching overlay settings: ${e.message}")
                                Toast.makeText(this, "无法打开设置", Toast.LENGTH_SHORT).show()
                            }
                        }.show()
                    } else {
                        // 记录开始启动悬浮窗
                        Log.d("MainActivity", "Starting floating window")
                        // 启动悬浮窗服务
                        startFloatingWindow()
                        // 更新按钮状态为已启动
                        updateCircleButtonState(true)
                    }
                } else {
                    // 记录悬浮窗已经启动
                    Log.d("MainActivity", "Floating window already started")
                }
            }

            // 记录按钮初始化成功
            Log.d("MainActivity", "Circle button initialized successfully")
        } catch (e: Exception) {
            // 记录按钮初始化失败的错误
            Log.e("MainActivity", "Error initializing circle button: ${e.message}")
            e.printStackTrace()
            // 显示错误提示，但不退出应用
            try {
                // 尝试使用Snackbar显示错误
                Snackbar.make(
                    binding.root,
                    "初始化按钮失败，部分功能可能无法使用",
                    Snackbar.LENGTH_LONG
                ).show()
            } catch (e: Exception) {
                // 记录Snackbar显示失败的错误
                Log.e("MainActivity", "Could not show error snackbar: ${e.message}")
                // 如果Snackbar显示失败，尝试使用Toast
                try {
                    Toast.makeText(this, "初始化按钮失败，部分功能可能无法使用", Toast.LENGTH_LONG).show()
                } catch (e: Exception) {
                    // 记录Toast显示失败的错误
                    Log.e("MainActivity", "Could not show error toast: ${e.message}")
                }
            }
        }
    }

    /**
     * 更新圆形按钮状态
     * 同时更新按钮的选中状态和悬浮窗状态标志
     * @param isStarted 悬浮窗是否已启动的标志
     */
    private fun updateCircleButtonState(isStarted: Boolean) {
        // 更新悬浮窗状态标志
        isFloatingWindowStarted = isStarted
        // 更新按钮的选中状态，用于显示不同的视觉效果
        circleButton.isSelected = isStarted
    }

    /**
     * 启动悬浮窗服务
     * 包含权限检查、服务状态检查和错误处理
     * 成功启动后会更新UI状态
     */
    private fun startFloatingWindow() {
        try {
            // 检查Android 6.0及以上版本的悬浮窗权限
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.canDrawOverlays(this)) {
                // 记录权限缺失错误
                Log.e("MainActivity", "没有悬浮窗权限")
                // 显示Snackbar提示用户需要权限
                Snackbar.make(
                    binding.root,
                    "需要悬浮窗权限才能显示悬浮窗",
                    Snackbar.LENGTH_LONG
                ).setAction("去设置") {
                    try {
                        // 创建打开悬浮窗权限设置的Intent
                        val intent = Intent(
                            Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                            Uri.parse("package:$packageName")
                        )
                        // 启动权限设置界面
                        overlayPermissionLauncher.launch(intent)
                    } catch (e: Exception) {
                        // 记录打开设置失败的错误
                        Log.e("MainActivity", "打开悬浮窗设置失败: ${e.message}")
                        Toast.makeText(this, "无法打开设置", Toast.LENGTH_SHORT).show()
                    }
                }.show()
                return
            }
            
            // 检查服务是否已经在运行
            if (isFloatingWindowStarted) {
                // 记录服务已运行的信息
                Log.d("MainActivity", "悬浮窗服务已在运行")
                Toast.makeText(this, "悬浮窗服务已在运行", Toast.LENGTH_SHORT).show()
                return
            }

            // 尝试启动服务
            try {
                // 记录开始启动服务
                Log.d("MainActivity", "开始启动悬浮窗服务")
                // 创建启动服务的Intent
                val serviceIntent = Intent(this, FloatingWindowService::class.java)
                // 启动服务
                startService(serviceIntent)
                // 更新服务状态标志
                isFloatingWindowStarted = true
                // 更新按钮UI状态
                updateCircleButtonState(true)
                // 记录服务启动成功
                Log.d("MainActivity", "悬浮窗服务启动成功")
            } catch (e: Exception) {
                // 记录服务启动失败的错误
                Log.e("MainActivity", "启动悬浮窗服务失败: ${e.message}")
                e.printStackTrace()
                // 更新状态标志为未启动
                isFloatingWindowStarted = false
                // 更新按钮UI状态为未启动
                updateCircleButtonState(false)
                // 显示错误提示
                Toast.makeText(this, "启动悬浮窗服务失败", Toast.LENGTH_SHORT).show()
            }
            
        } catch (e: Exception) {
            // 记录整体流程错误
            Log.e("MainActivity", "启动悬浮窗时发生错误: ${e.message}")
            e.printStackTrace()
            // 更新状态标志为未启动
            isFloatingWindowStarted = false
            // 更新按钮UI状态为未启动
            updateCircleButtonState(false)
            // 显示错误提示
            Snackbar.make(
                binding.root,
                "启动悬浮窗失败，请稍后重试",
                Snackbar.LENGTH_LONG
            ).show()
        }
    }

    /**
     * 创建选项菜单
     * 根据导航视图的可见性决定是否显示溢出菜单
     * @param menu 要填充的菜单对象
     * @return Boolean 返回true表示菜单已创建
     */
    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        // 调用父类的onCreateOptionsMenu方法
        val result = super.onCreateOptionsMenu(menu)
        // 查找导航视图组件
        val navView: NavigationView? = findViewById(R.id.nav_view)
        if (navView == null) {
            // 如果导航视图不可见，填充溢出菜单
            menuInflater.inflate(R.menu.overflow, menu)
        }
        return result
    }

    /**
     * 处理选项菜单项的选择事件
     * @param item 被选中的菜单项
     * @return Boolean 返回true表示事件已处理
     */
    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        when (item.itemId) {
            R.id.nav_settings -> {
                // 导航到设置页面
                findNavController(R.id.nav_host_fragment_content_main).navigate(R.id.nav_settings)
                return true
            }
        }
        // 如果未处理，交给父类处理
        return super.onOptionsItemSelected(item)
    }

    /**
     * 检查悬浮窗权限状态
     * 对于Android 6.0及以上版本，需要动态检查权限
     * 对于低版本Android，默认拥有权限
     * @return Boolean 返回true表示有悬浮窗权限
     */
    private fun checkOverlayPermission(): Boolean {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // Android 6.0及以上版本需要动态检查悬浮窗权限
            Settings.canDrawOverlays(this)
        } else {
            // Android 6.0以下版本默认拥有权限
            true
        }
    }

    /**
     * Activity恢复到前台时调用
     * 用于检查和同步悬浮窗状态
     */
    override fun onResume() {
        super.onResume()
        // 检查悬浮窗服务状态并同步按钮状态
        if (::circleButton.isInitialized) {
            val hasPermission = checkOverlayPermission()
            if (!hasPermission) {
                isFloatingWindowStarted = false
                updateCircleButtonState(false)
            }
        }
        
        // 只在对话框未显示时检查无障碍服务状态
        if (!isShowingAccessibilityDialog) {
            binding.root.postDelayed({
                try {
                    val isEnabled = isAccessibilityServiceEnabled()
                    Log.d("MainActivity", "Accessibility service status on resume: $isEnabled")
                    if (!isEnabled) {
                        checkAndRequestPermissions()
                    }
                } catch (e: Exception) {
                    Log.e("MainActivity", "Error checking accessibility service on resume: ${e.message}")
                }
            }, 1000) // 延迟1秒检查，确保系统设置已更新
        }
    }

    /**
     * Activity销毁时调用
     * 用于清理资源和重置状态
     */
    override fun onDestroy() {
        super.onDestroy()
        // 停止悬浮窗服务
        if (isFloatingWindowStarted) {
            try {
                val serviceIntent = Intent(this, FloatingWindowService::class.java)
                stopService(serviceIntent)
                isFloatingWindowStarted = false
            } catch (e: Exception) {
                Log.e("MainActivity", "Error stopping floating window service: ${e.message}")
            }
        }
    }

    /**
     * 检查无障碍服务是否启用
     */
    private fun isAccessibilityServiceEnabled(): Boolean {
        try {
            val am = getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager
            val serviceClassName = "${packageName}.service.MyAccessibilityService"
            Log.d("MainActivity", "Looking for service: $serviceClassName")
            
            // 方法1: 通过系统设置检查
            val enabledServicesString = Settings.Secure.getString(
                contentResolver,
                Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES
            )
            Log.d("MainActivity", "Enabled services in settings: $enabledServicesString")
            
            // 检查服务是否在已启用列表中
            if (enabledServicesString?.contains(serviceClassName) == true) {
                Log.d("MainActivity", "Service found in settings")
                return true
            }
            
            // 方法2: 通过AccessibilityManager检查
            val runningServices = am.getEnabledAccessibilityServiceList(
                AccessibilityServiceInfo.FEEDBACK_ALL_MASK
            )
            
            for (service in runningServices) {
                val id = service.id
                Log.d("MainActivity", "Found running service: $id")
                if (id.contains(serviceClassName)) {
                    Log.d("MainActivity", "Service is running")
                    return true
                }
            }
            
            Log.d("MainActivity", "Service not found")
            return false
            
        } catch (e: Exception) {
            Log.e("MainActivity", "Error checking accessibility service: ${e.message}")
            e.printStackTrace()
            return false
        }
    }

    override fun onNavigationItemSelected(item: MenuItem): Boolean {
        try {
            when (item.itemId) {
                R.id.nav_settings -> {
                    findNavController(R.id.nav_host_fragment_content_main).navigate(R.id.nav_settings)
                }
                R.id.nav_transform -> {
                    findNavController(R.id.nav_host_fragment_content_main).navigate(R.id.nav_transform)
                }
                R.id.nav_reflow -> {
                    findNavController(R.id.nav_host_fragment_content_main).navigate(R.id.nav_reflow)
                }
                R.id.nav_slideshow -> {
                    findNavController(R.id.nav_host_fragment_content_main).navigate(R.id.nav_slideshow)
                }
                R.id.nav_language -> {
                    showLanguageDialog()
                }
                R.id.nav_logs -> {
                    showLogsDialog()
                }
            }
            
            // 关闭抽屉
            drawerLayout?.closeDrawer(GravityCompat.START)
            return true
        } catch (e: Exception) {
            Log.e("MainActivity", "Error handling navigation item selection: ${e.message}")
            return false
        }
    }

    /**
     * 关闭抽屉
     */
    fun closeDrawer() {
        try {
            drawerLayout?.closeDrawer(GravityCompat.START)
        } catch (e: Exception) {
            Log.e("MainActivity", "Error closing drawer: ${e.message}")
        }
    }

    /**
     * 处理返回键
     */
    override fun onBackPressed() {
        try {
            // 如果抽屉打开，先关闭抽屉
            if (drawerLayout?.isDrawerOpen(GravityCompat.START) == true) {
                closeDrawer()
            } else {
                super.onBackPressed()
            }
        } catch (e: Exception) {
            Log.e("MainActivity", "Error handling back press: ${e.message}")
            super.onBackPressed()
        }
    }

    /**
     * 处理向上导航
     * 实现应用栏上的返回按钮功能
     * @return Boolean 返回true表示导航成功
     */
    override fun onSupportNavigateUp(): Boolean {
        try {
            // 获取导航控制器
            val navController = findNavController(R.id.nav_host_fragment_content_main)
            // 尝试向上导航，如果失败则交给父类处理
            return navController.navigateUp(appBarConfiguration) || super.onSupportNavigateUp()
        } catch (e: Exception) {
            // 记录导航失败的错误
            Log.e("MainActivity", "Error handling up navigation: ${e.message}")
            return super.onSupportNavigateUp()
        }
    }

    /**
     * 显示语言选择对话框
     * 提供多语言切换功能
     * 包括：系统默认、中文、英文、日文、韩文
     */
    private fun showLanguageDialog() {
        try {
            // 定义支持的语言选项数组
            val languages = arrayOf(
                getString(R.string.language_auto),    // 跟随系统
                getString(R.string.language_zh),      // 中文
                getString(R.string.language_en),      // 英文
                getString(R.string.language_ja),      // 日文
                getString(R.string.language_ko)       // 韩文
            )
            
            // 获取当前设置的语言
            val currentLanguage = getSharedPreferences("settings", Context.MODE_PRIVATE)
                .getString("language", "auto") ?: "auto"
            
            // 确定当前语言在选项中的位置
            val currentIndex = when(currentLanguage) {
                "auto" -> 0  // 跟随系统
                "zh" -> 1    // 中文
                "en" -> 2    // 英文
                "ja" -> 3    // 日文
                "ko" -> 4    // 韩文
                else -> 0    // 默认跟随系统
            }

            // 创建并显示语言选择对话框
            AlertDialog.Builder(this)
                .setTitle(getString(R.string.language_settings))
                .setSingleChoiceItems(languages, currentIndex) { dialog, which ->
                    // 根据选择的位置确定语言代码
                    val language = when(which) {
                        0 -> "auto"  // 跟随系统
                        1 -> "zh"    // 中文
                        2 -> "en"    // 英文
                        3 -> "ja"    // 日文
                        4 -> "ko"    // 韩文
                        else -> "auto"  // 默认跟随系统
                    }
                    
                    // 保存语言设置到SharedPreferences
                    getSharedPreferences("settings", Context.MODE_PRIVATE)
                        .edit()
                        .putString("language", language)
                        .apply()
                    
                    // 提示用户需要重启应用
                    Toast.makeText(this, getString(R.string.language_change_restart), Toast.LENGTH_LONG).show()
                    dialog.dismiss()
                }
                .setNegativeButton(android.R.string.cancel, null)  // 取消按钮
                .show()
        } catch (e: Exception) {
            // 记录显示语言对话框失败的错误
            Log.e("MainActivity", "Error showing language dialog: ${e.message}")
            Toast.makeText(this, "显示语言设置失败", Toast.LENGTH_SHORT).show()
        }
    }

    /**
     * 显示日志对话框
     * 提供查看、复制、清除日志的功能
     */
    private fun showLogsDialog() {
        try {
            // 获取日志文件
            val logFile = File(getExternalFilesDir(null), "app.log")
            // 读取日志内容，如果文件不存在则显示空日志提示
            val logContent = if (logFile.exists()) {
                logFile.readText()
            } else {
                getString(R.string.logs_empty)
            }

            // 创建并显示日志对话框
            val dialog = AlertDialog.Builder(this)
                .setTitle(getString(R.string.logs_title))
                .setMessage(logContent)
                .setPositiveButton(getString(R.string.logs_clear)) { _, _ ->
                    try {
                        // 清除日志文件
                        logFile.delete()
                        Toast.makeText(this, getString(R.string.log_cleared), Toast.LENGTH_SHORT).show()
                    } catch (e: Exception) {
                        // 记录清除日志失败的错误
                        Log.e("MainActivity", "Error clearing logs: ${e.message}")
                    }
                }
                .setNeutralButton(getString(R.string.logs_copy)) { _, _ ->
                    try {
                        // 复制日志内容到剪贴板
                        val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager
                        val clip = android.content.ClipData.newPlainText("日志", logContent)
                        clipboard.setPrimaryClip(clip)
                        Toast.makeText(this, getString(R.string.log_copied), Toast.LENGTH_SHORT).show()
                    } catch (e: Exception) {
                        // 记录复制日志失败的错误
                        Log.e("MainActivity", "Error copying logs: ${e.message}")
                    }
                }
                .setNegativeButton(android.R.string.cancel, null)  // 取消按钮
                .create()

            // 显示对话框
            dialog.show()
        } catch (e: Exception) {
            // 记录显示日志对话框失败的错误
            Log.e("MainActivity", "Error showing logs dialog: ${e.message}")
            Toast.makeText(this, "显示日志失败", Toast.LENGTH_SHORT).show()
        }
    }
}